package org.jeecg.modules.middle.business.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.system.vo.SelectTreeModel;
import org.jeecg.common.util.TokenUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.manage.entity.CaishuiBusiness;
import org.jeecg.modules.manage.entity.CaishuiBusinessBank;
import org.jeecg.modules.manage.entity.CaishuiBusinessUser;
import org.jeecg.modules.middle.business.mapper.CaishuiBusinessBankMapper;
import org.jeecg.modules.middle.business.mapper.CaishuiBusinessMapper;
import org.jeecg.modules.middle.business.mapper.CaishuiBusinessUserMapper;
import org.jeecg.modules.middle.business.service.ICaishuiBusinessService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Collection;

/**
 * @Description: 商户基本信息表
 * @Author: yfkj
 * @Date:   2023-02-07
 * @Version: V1.0
 */
@Service
public class CaishuiBusinessServiceImpl extends ServiceImpl<CaishuiBusinessMapper, CaishuiBusiness> implements ICaishuiBusinessService {

	@Resource
	private CaishuiBusinessMapper caishuiBusinessMapper;
	@Resource
	private CaishuiBusinessUserMapper caishuiBusinessUserMapper;
	@Resource
	private CaishuiBusinessBankMapper caishuiBusinessBankMapper;


	//=================================树结构============================
	@Override
	public void addCaishuiBusiness(CaishuiBusiness caishuiBusiness) {
		//新增时设置hasChild为0
		caishuiBusiness.setHasChild(ICaishuiBusinessService.NOCHILD);
		if(oConvertUtils.isEmpty(caishuiBusiness.getPid())){
			caishuiBusiness.setPid(ICaishuiBusinessService.ROOT_PID_VALUE);
		}else{
			//如果当前节点父ID不为空 则设置父节点的hasChildren 为1
			CaishuiBusiness parent = baseMapper.selectById(caishuiBusiness.getPid());
			if(parent!=null && !"1".equals(parent.getHasChild())){
				parent.setHasChild("1");
				baseMapper.updateById(parent);
			}
		}
		LoginUser loginUser = TokenUtils.getLoginUser();
		caishuiBusiness.setCreateBy(loginUser.getRealname());
		caishuiBusiness.setUserId(loginUser.getId());
		if(loginUser.getUserType()==2 && loginUser.getMiddleOptAuth()==2) {//中台渠道角色
			caishuiBusiness.setChannelBusinessId(loginUser.getChannelBusinessId());
		}
		baseMapper.insert(caishuiBusiness);
	}

	@Override
	public void updateCaishuiBusiness(CaishuiBusiness caishuiBusiness) {
		CaishuiBusiness entity = this.getById(caishuiBusiness.getId());
		if(entity==null) {
			throw new JeecgBootException("未找到对应实体");
		}
		String old_pid = entity.getPid();
		String new_pid = caishuiBusiness.getPid();
		if(!old_pid.equals(new_pid)) {
			updateOldParentNode(old_pid);
			if(oConvertUtils.isEmpty(new_pid)){
				caishuiBusiness.setPid(ICaishuiBusinessService.ROOT_PID_VALUE);
			}
			if(!ICaishuiBusinessService.ROOT_PID_VALUE.equals(caishuiBusiness.getPid())) {
				baseMapper.updateTreeNodeStatus(caishuiBusiness.getPid(), ICaishuiBusinessService.HASCHILD);
			}
		}
		//当前登录用户
		LoginUser loginUser = TokenUtils.getLoginUser();
		caishuiBusiness.setUpdateBy(loginUser.getRealname());
		baseMapper.updateById(caishuiBusiness);
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void deleteCaishuiBusiness(String id) throws JeecgBootException {
		/**1、删除商户基本信息*/
		//查询选中节点下所有子节点一并删除
		id = this.queryTreeChildIds(id);
		if(id.indexOf(",")>0) {
			StringBuffer sb = new StringBuffer();
			String[] idArr = id.split(",");
			for (String idVal : idArr) {
				if(idVal != null){
					CaishuiBusiness caishuiBusiness = this.getById(idVal);
					String pidVal = caishuiBusiness.getPid();
					//查询此节点上一级是否还有其他子节点
					List<CaishuiBusiness> dataList = baseMapper.selectList(new QueryWrapper<CaishuiBusiness>().eq("pid", pidVal).notIn("id", Arrays.asList(idArr)));
					boolean flag = (dataList == null || dataList.size() == 0) && !Arrays.asList(idArr).contains(pidVal) && !sb.toString().contains(pidVal);
					if(flag){
						//如果当前节点原本有子节点 现在木有了，更新状态
						sb.append(pidVal).append(",");
					}
				}
			}
			//批量删除节点
			baseMapper.deleteBatchIds(Arrays.asList(idArr));
			//修改已无子节点的标识
			String[] pidArr = sb.toString().split(",");
			for(String pid : pidArr){
				this.updateOldParentNode(pid);
			}
		}else{
			CaishuiBusiness caishuiBusiness = this.getById(id);
			if(caishuiBusiness==null) {
				throw new JeecgBootException("未找到对应实体");
			}
			updateOldParentNode(caishuiBusiness.getPid());
			baseMapper.deleteById(id);
		}

		/**2、删除商户银行信息*/
		/**3、删除商户用户信息*/
	}

	@Override
	public List<CaishuiBusiness> queryTreeListNoPage(QueryWrapper<CaishuiBusiness> queryWrapper) {
		List<CaishuiBusiness> dataList = baseMapper.selectList(queryWrapper);
		List<CaishuiBusiness> mapList = new ArrayList<>();
		for(CaishuiBusiness data : dataList){
			String pidVal = data.getPid();
			//递归查询子节点的根节点
			if(pidVal != null && !ICaishuiBusinessService.NOCHILD.equals(pidVal)){
				CaishuiBusiness rootVal = this.getTreeRoot(pidVal);
				if(rootVal != null && !mapList.contains(rootVal)){
					mapList.add(rootVal);
				}
			}else{
				if(!mapList.contains(data)){
					mapList.add(data);
				}
			}
		}
		return mapList;
	}

	@Override
	public List<SelectTreeModel> queryListByCode(String parentCode) {
		String pid = ROOT_PID_VALUE;
		if (oConvertUtils.isNotEmpty(parentCode)) {
			LambdaQueryWrapper<CaishuiBusiness> queryWrapper = new LambdaQueryWrapper<>();
			queryWrapper.eq(CaishuiBusiness::getPid, parentCode);
			List<CaishuiBusiness> list = baseMapper.selectList(queryWrapper);
			if (list == null || list.size() == 0) {
				throw new JeecgBootException("该编码【" + parentCode + "】不存在，请核实!");
			}
			if (list.size() > 1) {
				throw new JeecgBootException("该编码【" + parentCode + "】存在多个，请核实!");
			}
			pid = list.get(0).getId();
		}
		return baseMapper.queryListByPid(pid, null);
	}

	@Override
	public List<SelectTreeModel> queryListByPid(String pid) {
		if (oConvertUtils.isEmpty(pid)) {
			pid = ROOT_PID_VALUE;
		}
		return baseMapper.queryListByPid(pid, null);
	}

	/**
	 * 根据所传pid查询旧的父级节点的子节点并修改相应状态值
	 * @param pid
	 */
	private void updateOldParentNode(String pid) {
		if(!ICaishuiBusinessService.ROOT_PID_VALUE.equals(pid)) {
			Long count = baseMapper.selectCount(new QueryWrapper<CaishuiBusiness>().eq("pid", pid));
			if(count==null || count<=1) {
				baseMapper.updateTreeNodeStatus(pid, ICaishuiBusinessService.NOCHILD);
			}
		}
	}

	/**
	 * 递归查询节点的根节点
	 * @param pidVal
	 * @return
	 */
	private CaishuiBusiness getTreeRoot(String pidVal){
		CaishuiBusiness data =  baseMapper.selectById(pidVal);
		if(data != null && !ICaishuiBusinessService.ROOT_PID_VALUE.equals(data.getPid())){
			return this.getTreeRoot(data.getPid());
		}else{
			return data;
		}
	}

	/**
	 * 根据id查询所有子节点id
	 * @param ids
	 * @return
	 */
	private String queryTreeChildIds(String ids) {
		//获取id数组
		String[] idArr = ids.split(",");
		StringBuffer sb = new StringBuffer();
		for (String pidVal : idArr) {
			if(pidVal != null){
				if(!sb.toString().contains(pidVal)){
					if(sb.toString().length() > 0){
						sb.append(",");
					}
					sb.append(pidVal);
					this.getTreeChildIds(pidVal,sb);
				}
			}
		}
		return sb.toString();
	}

	/**
	 * 递归查询所有子节点
	 * @param pidVal
	 * @param sb
	 * @return
	 */
	private StringBuffer getTreeChildIds(String pidVal,StringBuffer sb){
		List<CaishuiBusiness> dataList = baseMapper.selectList(new QueryWrapper<CaishuiBusiness>().eq("pid", pidVal));
		if(dataList != null && dataList.size()>0){
			for(CaishuiBusiness tree : dataList) {
				if(!sb.toString().contains(tree.getId())){
					sb.append(",").append(tree.getId());
				}
				this.getTreeChildIds(tree.getId(),sb);
			}
		}
		return sb;
	}
	//=================================树结构============================

	//=================================一对多结构============================
	@Override
	@Transactional(rollbackFor = Exception.class)
	public void saveMain(CaishuiBusiness caishuiBusiness, List<CaishuiBusinessUser> caishuiBusinessUserList, List<CaishuiBusinessBank> caishuiBusinessBankList) {
		caishuiBusinessMapper.insert(caishuiBusiness);
		if(caishuiBusinessUserList!=null && caishuiBusinessUserList.size()>0) {
			for(CaishuiBusinessUser entity:caishuiBusinessUserList) {
				//外键设置
				entity.setBusinessId(caishuiBusiness.getId());
				caishuiBusinessUserMapper.insert(entity);
			}
		}
		if(caishuiBusinessBankList!=null && caishuiBusinessBankList.size()>0) {
			for(CaishuiBusinessBank entity:caishuiBusinessBankList) {
				//外键设置
				entity.setBusinessId(caishuiBusiness.getId());
				caishuiBusinessBankMapper.insert(entity);
			}
		}
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void updateMain(CaishuiBusiness caishuiBusiness,List<CaishuiBusinessUser> caishuiBusinessUserList,List<CaishuiBusinessBank> caishuiBusinessBankList) {
		caishuiBusinessMapper.updateById(caishuiBusiness);

		//1.先删除子表数据
		caishuiBusinessUserMapper.deleteByMainId(caishuiBusiness.getId());
		caishuiBusinessBankMapper.deleteByMainId(caishuiBusiness.getId());

		//2.子表数据重新插入
		if(caishuiBusinessUserList!=null && caishuiBusinessUserList.size()>0) {
			for(CaishuiBusinessUser entity:caishuiBusinessUserList) {
				//外键设置
				entity.setBusinessId(caishuiBusiness.getId());
				caishuiBusinessUserMapper.insert(entity);
			}
		}
		if(caishuiBusinessBankList!=null && caishuiBusinessBankList.size()>0) {
			for(CaishuiBusinessBank entity:caishuiBusinessBankList) {
				//外键设置
				entity.setBusinessId(caishuiBusiness.getId());
				caishuiBusinessBankMapper.insert(entity);
			}
		}
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void delMain(String id) {
		caishuiBusinessUserMapper.deleteByMainId(id);
		caishuiBusinessBankMapper.deleteByMainId(id);
		caishuiBusinessMapper.deleteById(id);
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void delBatchMain(Collection<? extends Serializable> idList) {
		for(Serializable id:idList) {
			caishuiBusinessUserMapper.deleteByMainId(id.toString());
			caishuiBusinessBankMapper.deleteByMainId(id.toString());
			caishuiBusinessMapper.deleteById(id);
		}
	}
	//=================================一对多结构============================
}
